home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / presto / prest1_0.lha / src / presto.C < prev    next >
C/C++ Source or Header  |  1991-12-11  |  7KB  |  285 lines
  1. /*
  2.  * presto.c
  3.  *
  4.  *    Main PRESTO bootstrapping code.  Works something like this:
  5.  *
  6.  *    main()
  7.  *        Create a new MAIN object.
  8.  *        delete the scheduler thread
  9.  *        exit
  10.  *
  11.  *    Main::Main()
  12.  *        Call Main::init giving programmer chance to set up
  13.  *        initial parameters.
  14.  *
  15.  *    -    Bind "thisthread" to the default thread we get from UNIX.
  16.  *    -    Create a new scheduler object.
  17.  *    -    Create a thread to run in the scheduler object.
  18.  *    -    Start new thread in scheduler object.  We are running 
  19.  *        without preemption and with a single processor at this
  20.  *        point, so the start just puts the thread/scheduler pair
  21.  *        on the ready queue.
  22.  *    -    Create nummainthreads bound to Main::main and "start" them
  23.  *        by placing them on the run queue.  Again, we know that 
  24.  *        they won't run until the scheduler actually kicks in.
  25.  *
  26.  *    -    Invoke "thisproc" getting it to start pulling threads
  27.  *        off the readyq.
  28.  */
  29.  
  30. #define _PRESTO_C
  31.  
  32.  
  33. #include <stddef.h>
  34. #include <sys/types.h>
  35. #include <osfcn.h>
  36. #include <stream.h>
  37. #include "presto.h"
  38.  
  39. Main            *MAIN;
  40. Scheduler    *sched;            // does not need to be shared,
  41.                     // just what it references does
  42.  
  43. static int main_exit_code = 0;        // how we leave
  44. shared_t int prestoState = STATIC_CTOR;
  45.  
  46. start_Scheduler (Scheduler *s)
  47.  
  48. {
  49.   return s->invoke();
  50. }
  51.  
  52. start_Main (Main *m)
  53.  
  54. {
  55.   return m->main ();
  56. }
  57.  
  58. Main::Main(int ac, char **ap, char **ep)
  59. {
  60.     argc = ac;
  61.     argv = ap;
  62.     envp = ep;
  63.     numprocessors = 1;
  64.     mainstacksizes = DEFSTACKSIZ;
  65.     nummainthreads = 1;
  66.     stacksize = DEFSTACKSIZ;
  67.     quantum = DEFQUANTUM;
  68. #ifdef i386
  69.     affinity = 0;
  70. #endif /* i386 */
  71. #ifdef PROFILE
  72.     numprofilers = 1;
  73.     QInit();
  74. #endif
  75. }
  76.  
  77.  
  78. void
  79. Main::run ()
  80. {
  81.     Thread *t, *mainthread;
  82.  
  83.     mainthread = new Thread("_MAIN_", 0, 0);    // run on same stack
  84.     mainthread->setflags(TF_SCHEDULER|TF_KEEPSTACK|TF_NONPREEMPTABLE);
  85.  
  86.     //
  87.     // "thisthread" refers to the current thread of execution running
  88.     // right here, right now.  Make our thread point at the static process
  89.     // object until we have our own process object to reference into.
  90.     //
  91.     mainthread->setproc(sysproc);
  92.     thisthread = mainthread;
  93.  
  94.     prestoState = MAIN_INIT;
  95.     // give the programmer a chance
  96.     if (main_exit_code = Main::init())    {    // non-zero return
  97.         return;                    // is bad news
  98.     }
  99.  
  100. #ifdef PROFILE
  101.     if ((numprocessors + numprofilers) > NUMPROCS)
  102.         {
  103.         cout << "Too many processors: " << numprocessors 
  104.                     << numprofilers << "\n";
  105.         return;                    // is bad news
  106.         }
  107.     QBegin(numprocessors, numprofilers, affinity);
  108. #endif
  109.  
  110. #ifdef sun
  111.     numprocessors = 1;
  112. #endif /* sun */
  113. #if defined(vax)
  114.     // VAX unix version runs on uniprocessors only for now.
  115.     numprocessors = 1;
  116. #endif /* vax */
  117. #ifdef mips
  118.     numprocessors = 1;
  119. #endif /* mips */
  120.  
  121.     if (thisthread != mainthread)
  122.         thisthread = mainthread;
  123.     prestoState = MAIN_MAIN;
  124.  
  125.     //
  126.     // prime the scheduler
  127.     //
  128. #ifdef DEBUG_STARTUP
  129.         cout << "invoking ctor for scheduler\n";
  130.     cout.flush();
  131. #endif /* DEBUG_STARTUP */
  132.     if (sched == (Scheduler*)0)
  133.         sched = new Scheduler(numprocessors,quantum);  // sets thisproc
  134.  
  135.     //
  136.     // t becomes the first schedulable thread
  137.     // Since we only have one processor, and no preemption here
  138.     // we return with t on the ready q.
  139.     //
  140. #ifdef DEBUG_STARTUP
  141.         cout << "making thread SCHEDULER_STARTER\n";
  142.     cout.flush();
  143. #endif /* DEBUG_STARTUP */
  144.     t = mainthread->newthread ("SCHEDULER_STARTER");
  145.     t->nonpreemptable();
  146.     t->start(0, (PFany) start_Scheduler, sched);
  147.  
  148.     //
  149.     // Build the main threads and readyq them
  150.     //
  151. #ifdef DEBUG_STARTUP
  152.         cout << "making the main threads\n";
  153.     cout.flush();
  154. #endif /* DEBUG_STARTUP */
  155.     for (int i = 0; i < nummainthreads; i++)    {
  156.         char buf[8];        // lotsa threads
  157.         sprintf(buf,"%s.%d", MAINNAME, i);
  158.         char *name = new char[strlen(buf)+1];
  159.         strcpy(name, buf);
  160.         Thread *t = mainthread->newthread (name, i+1, mainstacksizes);
  161.         t->start(0, (PFany) start_Main, this);
  162.     }
  163.  
  164.     // Crank up the scheduler in the context of thisthread.
  165.     //    This will read the SCHEDULER thread off the
  166.     //    the readyq, invoke that thread
  167.     //    on the scheduler itself, which will cause the scheduler
  168.     //    to then create numprocessors copies of itself (each
  169.     //    running on its own stack).  The SCHEDULER thread
  170.     //    is guaranteed not to block and will be the first thread
  171.     //    to terminate, so we can quickly reuse it.
  172.     //    
  173.  
  174.     //
  175.     // Bind this thread to a processor which will start up all the
  176.     // coschedulers.  Thisthread will not be queued since it's a scheduler.
  177.     // We have to start it up directly.
  178.     //
  179. #ifdef DEBUG_STARTUP
  180.         cout << "about to start scheduler\n"; cout.flush ();
  181.         cout.flush();
  182. #endif /* DEBUG_STARTUP */
  183.  
  184.     mainthread->isrunning();
  185.     thisproc->invoke();            // start thisproc which will start 
  186.                     // the scheduler thread which will
  187.                     // start all the processor threads
  188.                     // which will then pull the main
  189.                     // threads off the readyq
  190.     mainthread->isnotrunning();
  191.  
  192.     //
  193.     // Since shutdown is not synchronized, there is a race condition which
  194.     // can result in sched getting deleted while process objects are still
  195.     // active.  If it hurts, don't do it.
  196.     //
  197.     //    if (sched)
  198.     //        delete sched;
  199.     //
  200.  
  201.     delete thisproc;
  202.     thisproc = sysproc;
  203.  
  204.     //delete thisthread;         /* done in runrun */
  205.     //thisthread = 0;
  206.     //
  207.     // Threads are out... thisthread is undefined at this point
  208.     //
  209.     // should be single unix process by now
  210.  
  211.     cout << "HALT" << endl << flush;
  212.     prestoState = MAIN_DONE;
  213.     main_exit_code = Main::done();
  214. }
  215.  
  216.  
  217. Main::~Main()
  218. {
  219. }
  220.  
  221.  
  222. //
  223. // Preallocate tons of threads in the parent process's address space.
  224. // This is a temporary hack to get around the brain-damaged sequent
  225. // shared memory implementation.
  226. //
  227. // NOTE: not called from anywhere in Presto.
  228. //
  229. int
  230. Main::preallocthreads(int cnt, int sz)
  231. {
  232.     int j;
  233.  
  234.     j = cnt;
  235.     Thread **tlist = new Thread*[j];
  236.     while (j--)    {    
  237.         tlist[j] = thisthread->newthread ("any",    
  238.                     0,    // any id
  239.                     sz);    // stack size
  240.     }
  241.     j = cnt;
  242.     while (j--)    {
  243.         delete tlist[j];
  244.     }
  245.     delete tlist;
  246.     return cnt;
  247. }
  248.  
  249. typedef void    (*PF)();
  250. extern PF set_new_handler(PF);
  251. extern void failed_malloc();
  252.  
  253. void
  254. main(int argc, char **argv, char **envp)
  255. {
  256.     set_new_handler(failed_malloc);
  257.  
  258.     //
  259.     // Create a new main thread.
  260.     //
  261.  
  262.     MAIN = new Main(argc, argv, envp);
  263.         MAIN->run ();
  264.  
  265.     if (MAIN)
  266.         delete MAIN;
  267.  
  268.     prestoState = STATIC_DTOR;
  269.     
  270.     while (wait(0) != -1)        // collect kids, get execution stats
  271.         continue;
  272.  
  273. #ifdef __DECCXX
  274.     /* cxx has a wierd effect that shows up during the
  275.        static destructor calls that occur during an exit().
  276.        calling _exit() avoids this, but the problem
  277.        needs resolving.
  278.      */
  279.  
  280.     _exit(main_exit_code);
  281. #else
  282.     exit (main_exit_code);
  283. #endif /* __DECCXX */
  284. }    
  285.